<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-us" lang="en-us">
<head>
  <link href="//gmpg.org/xfn/11" rel="profile">
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <meta name="generator" content="Hugo 0.68.3" />

  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <title>python垃圾回收机制 &middot; 我的博客</title>

  
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/print.css" media="print">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/poole.css">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/syntax.css">
  <link type="text/css" rel="stylesheet" href="/my_technology_blog/css/hyde.css">
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Abril+Fatface|PT+Sans:400,400i,700">


  
  <link rel="apple-touch-icon-precomposed" sizes="144x144" href="/apple-touch-icon-144-precomposed.png">
  <link rel="shortcut icon" href="/favicon.png">

  
  
</head>

  <body class="theme-base-0b ">
  <aside class="sidebar">
  <div class="container sidebar-sticky">
    <div class="sidebar-about">
      <a href="/my_technology_blog/"><h1>我的博客</h1></a>
      <p class="lead">
       杨博的博客 
      </p>
    </div>

    <nav>
      <ul class="sidebar-nav">
        <li><a href="/my_technology_blog/">Home</a> </li>
        
      </ul>
    </nav>

    <p>&copy; 2021. All rights reserved. </p>
  </div>
</aside>

    <main class="content container">
    <div class="post">
  <h1>python垃圾回收机制</h1>
  <time datetime=2020-06-08T18:45:30&#43;0800 class="post-date">Mon, Jun 8, 2020</time>
  <h2 id="heading"></h2>
<p><!-- raw HTML omitted -->什么是内存管理和垃圾回收<!-- raw HTML omitted --></p>
<p>一 、什么是内存管理和垃圾回收
Python GC主要使用<!-- raw HTML omitted -->引用计数（reference counting）<!-- raw HTML omitted -->来跟踪和回收垃圾。在引用计数的基础上，通过<!-- raw HTML omitted -->“标记-清除”（mark and sweep）<!-- raw HTML omitted -->解决容器对象可能产生的循环引用问题，通过<!-- raw HTML omitted -->“分代回收”（generation collection）<!-- raw HTML omitted -->以空间换时间的方法提高垃圾回收效率。</p>
<p>现在的高级语言如java，c#等，都采用了垃圾收集机制，而不再是c，c++里用户自己管理维护内存的方式。自己管理内存极其自由，可以任意申请内存，但如同一把双刃剑，为大量内存泄露，悬空指针等bug埋下隐患。
对于一个字符串、列表、类甚至数值都是对象，且定位简单易用的语言，自然不会让用户去处理如何分配回收内存的问题。
python里也同java一样采用了垃圾收集机制，不过不一样的是:</p>
<p>最关键的一句话：</p>
<p><!-- raw HTML omitted -->python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略<!-- raw HTML omitted --></p>
<p><!-- raw HTML omitted -->一、引用计数——reference count<!-- raw HTML omitted --></p>
<p>PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。</p>
<p>优点:</p>
<ol>
<li>简单</li>
<li>实时性</li>
</ol>
<p>缺点:</p>
<p>那么关键问题来了，什么时候，引用计数增加1，什么时候引用计数减少1呢？</p>
<p>我们可以通过使用内置的模块<!-- raw HTML omitted -->sys.getrefcount(a)<!-- raw HTML omitted -->可以查看a对象的引用计数，但是比正常计数大1，因为调用函数的时候传入a，这会让a的引用计数+1。</p>
<p><!-- raw HTML omitted -->1、简单实例：<!-- raw HTML omitted --></p>
<ol>
<li>维护引用计数消耗资源</li>
<li>循环引用——最致命的缺点（后面会定义）</li>
<li><!-- raw HTML omitted -->导致引用计数+1的情况<!-- raw HTML omitted -->
<ol>
<li>对象被创建，例如<code>a=23</code></li>
<li>对象被引用，例如<code>b=a</code></li>
<li>对象被作为参数，传入到一个函数中，例如<code>func(a)</code></li>
<li>对象作为一个元素，存储在容器中，例如<code>list1=[a,a]</code></li>
</ol>
</li>
<li><!-- raw HTML omitted -->导致引用计数-1的情况<!-- raw HTML omitted -->
<ol>
<li>对象的别名被显式销毁，例如<code>del a</code></li>
<li>对象的别名被赋予新的对象，例如<code>a=24</code></li>
<li>一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）</li>
<li>对象所在的容器被销毁，或从容器中删除对象</li>
</ol>
</li>
</ol>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-python" data-lang="python"><span style="color:#f92672">import</span> sys
 
<span style="color:#66d9ef">class</span> <span style="color:#a6e22e">A</span>:
    <span style="color:#66d9ef">pass</span>
 
<span style="color:#66d9ef">def</span> <span style="color:#a6e22e">func</span>(x):
    <span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(x)-1}&#39;</span>,end<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;  &#39;</span>)
    <span style="color:#66d9ef">return</span> x
 
<span style="color:#75715e">#a=123.56</span>
a<span style="color:#f92672">=</span>A()       <span style="color:#75715e">#创建对象a</span>
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(a)-1}&#39;</span>)
b<span style="color:#f92672">=</span>a         <span style="color:#75715e">#再一次引用对象a</span>
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(a)-1}，对象b：{sys.getrefcount(b)-1}&#39;</span>)
c<span style="color:#f92672">=</span>func(a)   <span style="color:#75715e">#对象a作为函数参数</span>
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象c：{sys.getrefcount(c)-1}&#39;</span>)
d<span style="color:#f92672">=</span>list()    <span style="color:#75715e">#对象a作为列表元素</span>
d<span style="color:#f92672">.</span>append(a)
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(a)-1}，对象d：{sys.getrefcount(d)-1}&#39;</span>)
</code></pre></div><p>运行结果为：</p>
<p>对象a：1<br>
对象a：2，对象b：2<br>
对象a：4 , 对象c：3<br>
对象a：4，对象d：1</p>
<p><!-- raw HTML omitted --><strong>2、一个小的误区</strong><!-- raw HTML omitted --></p>
<p>a=100</p>
<p>sys.getrefcount(a)-1</p>
<p>返回结果为：50</p>
<p>这是为什么呢？</p>
<p>这是因为python系统维护着一个常见的“整数常量池”即-5-255，在这个区间的数字会有其他的处理方式，这说明100这个数字，目前在系统中有 50 个引用。包括字符串也有一些特殊的处理，所以在使用应用技术的时候，最好是使用自己自定义的数据类型，这样方便分析，这也是上面为什么要自定义一个类型A的原因。</p>
<p><!-- raw HTML omitted --><strong>3、减少引用的实例</strong><!-- raw HTML omitted --></p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-python" data-lang="python">
<span style="color:#f92672">import</span> sys
<span style="color:#66d9ef">class</span> <span style="color:#a6e22e">B</span>:
    <span style="color:#66d9ef">pass</span>
 
<span style="color:#66d9ef">del</span> d[<span style="color:#ae81ff">0</span>]  <span style="color:#75715e">#删除列表d中的元素a</span>
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(a)-1}，对象d：{sys.getrefcount(d)-1}&#39;</span>)
 
a<span style="color:#f92672">=</span>B()   <span style="color:#75715e"># a被重新复制，引用计数为1</span>
<span style="color:#66d9ef">print</span>(f<span style="color:#e6db74">&#39;对象a：{sys.getrefcount(a)-1}&#39;</span>)
<span style="color:#66d9ef">del</span> a   <span style="color:#75715e">#删除了a</span>
</code></pre></div><p>运行结果为：</p>
<p>对象a：3，对象d：1<br>
对象a：1</p>
<p><!-- raw HTML omitted --><strong>4、引用计数的致命缺陷——循环引用导致的内存泄漏</strong><!-- raw HTML omitted --></p>
<p>什么是内存泄漏呢？</p>
<p>指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。导致程序运行速度减慢甚至系统崩溃等严重后果。
有 <strong>del</strong>() 函数的对象间的循环引用是导致内存泄漏的主凶。不使用一个对象时使用:del object 来删除一个对象的引用计数就可以有效防止内存泄漏问题。通过 Python 扩展模块 gc 来查看不能回收的对象的详细信息。可以通过 sys.getrefcount(obj) 来获取对象的引用计数，并根据返回值是否为 0 来判断是否内存泄漏。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-python" data-lang="python">
<span style="color:#66d9ef">def</span> <span style="color:#a6e22e">f2</span>():
    <span style="color:#66d9ef">while</span> True:
        c1<span style="color:#f92672">=</span>ClassA()
        c2<span style="color:#f92672">=</span>ClassA()
        c1<span style="color:#f92672">.</span>t<span style="color:#f92672">=</span>c2
        c2<span style="color:#f92672">.</span>t<span style="color:#f92672">=</span>c1
        <span style="color:#66d9ef">del</span> c1
        <span style="color:#66d9ef">del</span> c2
</code></pre></div><p>创建了c1，c2后，0x237cf30（c1对应的内存，记为内存1）,0x237cf58（c2对应的内存，记为内存2）这两块内存的引用计数都是1，执行c1.t=c2和c2.t=c1后，这两块内存的引用计数变成2.
在del c1后，内存1的对象的引用计数变为1，由于不是为0，所以内存1的对象不会被销毁，所以内存2的对象的引用数依然是2，在del c2后，同理，内存1的对象，内存2的对象的引用数都是1。
虽然它们两个的对象都是可以被销毁的，但是由于<strong>循环引用</strong>，导致垃圾回收器都不会回收它们，所以就会导致内存泄露。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-python" data-lang="python">list1 <span style="color:#f92672">=</span> []
list2 <span style="color:#f92672">=</span> []
list1<span style="color:#f92672">.</span>append(list2)
list2<span style="color:#f92672">.</span>append(list1)
</code></pre></div><p>list1与list2相互引用，如果不存在其他对象对它们的引用，list1与list2的引用计数也仍然为1，所占用的内存永远无法被回收，这将是致命的。</p>
<p><!-- raw HTML omitted --><strong>5、针对“循环引用”的解决办法</strong><!-- raw HTML omitted --></p>
<ol>
<li><em><strong>*标记清除技术——mark and sweep*</strong></em></li>
<li><em><strong>*分代回收技术——generation collection*</strong></em></li>
<li><em><strong>*手动使用gc模块*</strong></em></li>
</ol>
<p><!-- raw HTML omitted -->二、标记-清除机制——mark and sweep<!-- raw HTML omitted --></p>
<p>基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历<!-- raw HTML omitted --><strong>以对象为节点、以引用为边构成的图</strong><!-- raw HTML omitted -->，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。</p>
<p>针对循环引用的情况：我们有一个“孤岛”或是一组未使用的、互相指向的对象，但是谁都没有外部引用。换句话说，我们的程序不再使用这些节点对象了，所以我们希望Python的垃圾回收机制能够足够智能去释放这些对象并回收它们占用的内存空间。但是这不可能，因为所有的引用计数都是1而不是0。Python的引用计数算法不能够处理互相指向自己的对象。你的代码也许会在不经意间包含循环引用并且你并未意识到。事实上，当你的Python程序运行的时候它将会建立一定数量的“浮点数垃圾”，Python的GC不能够处理未使用的对象因为应用计数值不会到零。
这就是为什么Python要引入Generational GC算法的原因！</p>
<p><!-- raw HTML omitted --> 『标记清除（Mark—Sweep）』算法是一种基于追踪回收（tracing GC）技术实现的垃圾回收算法。它分为两个阶段：第一阶段是标记阶段，GC会把所有的『活动对象』打上标记，第二阶段是把那些没有标记的对象『非活动对象』进行回收。那么GC又是如何判断哪些是活动对象哪些是非活动对象的呢？<!-- raw HTML omitted --></p>
<p><!-- raw HTML omitted --> 对象之间通过引用（指针）连在一起，构成一个有向图，对象构成这个有向图的节点，而引用关系构成这个有向图的边。从根对象（root object）出发，沿着有向边遍历对象，可达的（reachable）对象标记为活动对象，不可达的对象就是要被清除的非活动对象。根对象就是全局变量、调用栈、寄存器。<!-- raw HTML omitted --></p>
<p><img src="../public/img/biaoji.png" alt=""></p>
<p>在上图中，我们把小黑圈视为全局变量，也就是把它作为root object，从小黑圈出发，对象1可直达，那么它将被标记，对象2、3可间接到达也会被标记，而4和5不可达，那么1、2、3就是活动对象，4和5是非活动对象会被GC回收。</p>
<p>标记清除算法作为Python的辅助垃圾收集技术主要处理的是一些容器对象，比如list、dict、tuple，instance等，因为对于字符串、数值对象是不可能造成循环引用问题。Python使用一个双向链表将这些容器对象组织起来。不过，这种简单粗暴的标记清除算法也有明显的缺点：清除非活动的对象前它必须顺序扫描整个堆内存，哪怕只剩下小部分活动对象也要扫描所有对象。</p>
<p><!-- raw HTML omitted --><strong>三、分代技术——generation collection</strong><!-- raw HTML omitted --></p>
<p>分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。</p>
<p>Python默认定义了三代对象集合，索引数越大，对象存活时间越长。</p>
<ol>
<li>分代技术是一种典型的以空间换时间的技术，这也正是java里的关键技术。这种思想简单点说就是：<!-- raw HTML omitted -->**对象存在时间越长，越可能不是垃圾，应该越少去收集。**<!-- raw HTML omitted --></li>
<li>这样的思想，可以减少标记-清除机制所带来的额外操作。分代就是将回收对象分成数个代，每个代就是一个链表（集合），代进行标记-清除的时间与代内对象</li>
<li>存活时间成正比例关系。</li>
<li>从上面代码可以看出python里一共有三代，<!-- raw HTML omitted -->**每个代的threshold值表示该代最多容纳对象的个数。默认情况下，当0代超过700,或1，2代超过10，垃圾回收机制将触发。**<!-- raw HTML omitted --></li>
<li>0代触发将清理所有三代，1代触发会清理1,2代，2代触发后只会清理自己。</li>
</ol>
<p>举例： 当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中，当然，集合A中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。</p>
<p><!-- raw HTML omitted -->**总结：**<!-- raw HTML omitted --></p>
<p>分代回收是一种以空间换时间的操作方式，Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。同时，分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象.</p>
<p><!-- raw HTML omitted --><strong>四、垃圾回收与性能调优</strong><!-- raw HTML omitted --></p>
<ol>
<li>
<p>手动垃圾回收</p>
</li>
<li>
<p>调高垃圾回收阈值</p>
</li>
<li>
<p>避免循环引用（手动解循环引用和使用弱引用）</p>
</li>
<li></li>
</ol>

</div>


    </main>

    
  </body>
</html>
